#ifndef __STORMWIDGET_STORMWIDGET_BASECLASSLIBRARY_NUMBERIC_LIMITS_H
#define __STORMWIDGET_STORMWIDGET_BASECLASSLIBRARY_NUMBERIC_LIMITS_H

#include "bcl_config.h"
#include <ymath.h>
#include <cfloat>
#include <climits>
#include <cmath>
#include <cwchar>
#include <xstddef>

__BCL_BEGIN_NAMESPACE

enum float_round_style
{
	round_indeterminate       = -1,
	round_toward_zero         = 0,
	round_to_nearest          = 1,
	round_toward_infinity     = 2,
	round_toward_neg_infinity = 3
};

enum float_denorm_style
{
	denorm_indeterminate      = -1,
	denorm_absent             = 0,
	denorm_present            = 1
};

#define __BCL_DECLARE_LIMITS_MEMBER(__mem_type,__mem_name,__mem_value) \
	static const __mem_type __mem_name = __mem_value

#define __BCL_CONST_DEFIEND(__mem_cls,__mem_type,__mem_name)
//#define __BCL_CONST_DEFIEND(__mem_cls,__mem_type,__mem_name) \
//	const __mem_type __mem_cls::__mem_name

class _Numberic_limits_base
{
public:
	__BCL_DECLARE_LIMITS_MEMBER(bool,is_specialized,false);
	__BCL_DECLARE_LIMITS_MEMBER(int,digits,0);
	__BCL_DECLARE_LIMITS_MEMBER(int,digits10,0);
	__BCL_DECLARE_LIMITS_MEMBER(bool,is_signed,false);
	__BCL_DECLARE_LIMITS_MEMBER(bool,is_integer,false);
	__BCL_DECLARE_LIMITS_MEMBER(bool,is_exact,false);
	__BCL_DECLARE_LIMITS_MEMBER(int,radix,0);
	__BCL_DECLARE_LIMITS_MEMBER(int,min_exponent,0);
	__BCL_DECLARE_LIMITS_MEMBER(int,min_exponent10,0);
	__BCL_DECLARE_LIMITS_MEMBER(int,max_exponent,0);
	__BCL_DECLARE_LIMITS_MEMBER(int,max_exponent10,0);
	__BCL_DECLARE_LIMITS_MEMBER(bool,has_infinity,false);
	__BCL_DECLARE_LIMITS_MEMBER(bool,has_quiet_NaN,false);
	__BCL_DECLARE_LIMITS_MEMBER(bool,has_signaling_NaN,false);
	__BCL_DECLARE_LIMITS_MEMBER(float_denorm_style,has_denorm,denorm_absent);
	__BCL_DECLARE_LIMITS_MEMBER(bool,has_denorm_loss,false);
	__BCL_DECLARE_LIMITS_MEMBER(bool,is_iec559,false);
	__BCL_DECLARE_LIMITS_MEMBER(bool,is_bounded,false);
	__BCL_DECLARE_LIMITS_MEMBER(bool,is_modulo,false);
	__BCL_DECLARE_LIMITS_MEMBER(bool,traps,false);
	__BCL_DECLARE_LIMITS_MEMBER(bool,tinyness_before,false);
	__BCL_DECLARE_LIMITS_MEMBER(float_round_style,round_style,round_toward_zero);
};

__BCL_CONST_DEFIEND(_Numberic_limits_base, float_denorm_style, has_denorm);
__BCL_CONST_DEFIEND(_Numberic_limits_base, bool, has_denorm_loss);
__BCL_CONST_DEFIEND(_Numberic_limits_base, bool, has_infinity);
__BCL_CONST_DEFIEND(_Numberic_limits_base, bool, has_quiet_NaN);
__BCL_CONST_DEFIEND(_Numberic_limits_base, bool, has_signaling_NaN);
__BCL_CONST_DEFIEND(_Numberic_limits_base, bool, is_bounded);
__BCL_CONST_DEFIEND(_Numberic_limits_base, bool, is_exact);
__BCL_CONST_DEFIEND(_Numberic_limits_base, bool, is_iec559);
__BCL_CONST_DEFIEND(_Numberic_limits_base, bool, is_integer);
__BCL_CONST_DEFIEND(_Numberic_limits_base, bool, is_modulo);
__BCL_CONST_DEFIEND(_Numberic_limits_base, bool, is_signed);
__BCL_CONST_DEFIEND(_Numberic_limits_base, bool, is_specialized);
__BCL_CONST_DEFIEND(_Numberic_limits_base, bool, tinyness_before);
__BCL_CONST_DEFIEND(_Numberic_limits_base, bool, traps);
__BCL_CONST_DEFIEND(_Numberic_limits_base, float_round_style, round_style);
__BCL_CONST_DEFIEND(_Numberic_limits_base, int, digits);
__BCL_CONST_DEFIEND(_Numberic_limits_base, int, digits10);
__BCL_CONST_DEFIEND(_Numberic_limits_base, int, max_exponent);
__BCL_CONST_DEFIEND(_Numberic_limits_base, int, max_exponent10);
__BCL_CONST_DEFIEND(_Numberic_limits_base, int, min_exponent);
__BCL_CONST_DEFIEND(_Numberic_limits_base, int, min_exponent10);
__BCL_CONST_DEFIEND(_Numberic_limits_base, int, radix);


template <class __number>
class numberic_limits:public _Numberic_limits_base
{
public:
	static __number min() throw() { return __number(); }
	static __number max() throw() { return __number(); }
	static __number epsilon() throw() { return __number(); }
	static __number round_error() throw() { return __number(); }
	static __number denorm_min() throw() { return __number(); }
	static __number infinity() throw() { return __number(); }
	static __number quiet_NaN() throw() { return __number(); }
	static __number signaling_NaN() throw() { return __number(); }
};

class _Num_int_base : public _Numberic_limits_base
{
public:
	__BCL_DECLARE_LIMITS_MEMBER(bool, is_bounded, true);
	__BCL_DECLARE_LIMITS_MEMBER(bool, is_exact, true);
	__BCL_DECLARE_LIMITS_MEMBER(bool, is_integer, true);
	__BCL_DECLARE_LIMITS_MEMBER(bool, is_modulo, true);
	__BCL_DECLARE_LIMITS_MEMBER(bool, is_specialized, true);
	__BCL_DECLARE_LIMITS_MEMBER(int, radix, 2);
};

__BCL_CONST_DEFIEND(_Num_int_base, bool, is_bounded);
__BCL_CONST_DEFIEND(_Num_int_base, bool, is_exact);
__BCL_CONST_DEFIEND(_Num_int_base, bool, is_integer);
__BCL_CONST_DEFIEND(_Num_int_base, bool, is_modulo);
__BCL_CONST_DEFIEND(_Num_int_base, bool, is_specialized);
__BCL_CONST_DEFIEND(_Num_int_base, int, radix);

class _Num_float_base : public _Numberic_limits_base
{
public:
	__BCL_DECLARE_LIMITS_MEMBER(float_denorm_style, has_denorm, denorm_present);
	__BCL_DECLARE_LIMITS_MEMBER(bool, has_denorm_loss, true);
	__BCL_DECLARE_LIMITS_MEMBER(bool, has_infinity, true);
	__BCL_DECLARE_LIMITS_MEMBER(bool, has_quiet_NaN, true);
	__BCL_DECLARE_LIMITS_MEMBER(bool, has_signaling_NaN, true);
	__BCL_DECLARE_LIMITS_MEMBER(bool, is_bounded, true);
	__BCL_DECLARE_LIMITS_MEMBER(bool, is_exact, false);
	__BCL_DECLARE_LIMITS_MEMBER(bool, is_iec559, true);
	__BCL_DECLARE_LIMITS_MEMBER(bool, is_integer, false);
	__BCL_DECLARE_LIMITS_MEMBER(bool, is_modulo, false);
	__BCL_DECLARE_LIMITS_MEMBER(bool, is_signed, true);
	__BCL_DECLARE_LIMITS_MEMBER(bool, is_specialized, true);
	__BCL_DECLARE_LIMITS_MEMBER(bool, tinyness_before, true);
	__BCL_DECLARE_LIMITS_MEMBER(bool, traps, true);
	__BCL_DECLARE_LIMITS_MEMBER(float_round_style, round_style, round_to_nearest);
	__BCL_DECLARE_LIMITS_MEMBER(int, radix, FLT_RADIX);
};

__BCL_CONST_DEFIEND(_Num_float_base, float_denorm_style, has_denorm);
__BCL_CONST_DEFIEND(_Num_float_base, bool, has_denorm_loss);
__BCL_CONST_DEFIEND(_Num_float_base, bool, has_infinity);
__BCL_CONST_DEFIEND(_Num_float_base, bool, has_quiet_NaN);
__BCL_CONST_DEFIEND(_Num_float_base, bool, has_signaling_NaN);
__BCL_CONST_DEFIEND(_Num_float_base, bool, is_bounded);
__BCL_CONST_DEFIEND(_Num_float_base, bool, is_exact);
__BCL_CONST_DEFIEND(_Num_float_base, bool, is_iec559);
__BCL_CONST_DEFIEND(_Num_float_base, bool, is_integer);
__BCL_CONST_DEFIEND(_Num_float_base, bool, is_modulo);
__BCL_CONST_DEFIEND(_Num_float_base, bool, is_signed);
__BCL_CONST_DEFIEND(_Num_float_base, bool, is_specialized);
__BCL_CONST_DEFIEND(_Num_float_base, bool, tinyness_before);
__BCL_CONST_DEFIEND(_Num_float_base, bool, traps);
__BCL_CONST_DEFIEND(_Num_float_base, float_round_style, round_style);
__BCL_CONST_DEFIEND(_Num_float_base, int, radix);


__BCL_TEMPLATE_NULL class numberic_limits<char> :public _Numberic_limits_base
{
public:
	typedef char __number;

	static __number min() throw() { return (CHAR_MIN); }
	static __number max() throw() { return (CHAR_MAX); }
	static __number epsilon() throw() { return 0; }
	static __number round_error() throw() { return 0; }
	static __number denorm_min() throw() { return 0; }
	static __number infinity() throw() { return 0; }
	static __number quiet_NaN() throw() { return 0; }
	static __number signaling_NaN() throw() { return 0; }

	__BCL_DECLARE_LIMITS_MEMBER(bool, is_signed, CHAR_MIN != 0);
	__BCL_DECLARE_LIMITS_MEMBER(int, digits, CHAR_BIT - (CHAR_MIN != 0 ? 1 : 0));
	__BCL_DECLARE_LIMITS_MEMBER(int, digits10, (CHAR_BIT - (CHAR_MIN != 0 ? 1 : 0))
		* 301L / 1000);
};

__BCL_CONST_DEFIEND(numeric_limits<char>, bool, is_signed);
__BCL_CONST_DEFIEND(numeric_limits<char>, int, digits);
__BCL_CONST_DEFIEND(numeric_limits<char>, int, digits10);


__BCL_TEMPLATE_NULL class numberic_limits<wchar_t> :public _Numberic_limits_base
{
public:
	typedef wchar_t __number;

	static __number min() throw() { return (__number)(WCHAR_MIN); }
	static __number max() throw() { return (__number)(WCHAR_MAX); }
	static __number epsilon() throw() { return 0; }
	static __number round_error() throw() { return 0; }
	static __number denorm_min() throw() { return 0; }
	static __number infinity() throw() { return 0; }
	static __number quiet_NaN() throw() { return 0; }
	static __number signaling_NaN() throw() { return 0; }

	__BCL_DECLARE_LIMITS_MEMBER(bool, is_signed, WCHAR_MIN != 0);
	__BCL_DECLARE_LIMITS_MEMBER(int, digits, CHAR_BIT * sizeof (wchar_t)
		- (WCHAR_MIN != 0 ? 1 : 0));
	__BCL_DECLARE_LIMITS_MEMBER(int, digits10, (CHAR_BIT * sizeof (wchar_t)
		- (WCHAR_MIN != 0 ? 1 : 0)) * 301L / 1000);
};

__BCL_CONST_DEFIEND(numeric_limits<wchar_t>, bool, is_signed);
__BCL_CONST_DEFIEND(numeric_limits<wchar_t>, int, digits);
__BCL_CONST_DEFIEND(numeric_limits<wchar_t>, int, digits10);

__BCL_TEMPLATE_NULL class numberic_limits<bool> :public _Numberic_limits_base
{
public:
	typedef bool __number;
	static __number min() throw() { return (false); }
	static __number max() throw() { return (true); }
	static __number epsilon() throw() { return 0; }
	static __number round_error() throw() { return 0; }
	static __number denorm_min() throw() { return 0; }
	static __number infinity() throw() { return 0; }
	static __number quiet_NaN() throw() { return 0; }
	static __number signaling_NaN() throw() { return 0; }

	__BCL_DECLARE_LIMITS_MEMBER(bool, is_modulo, false);
	__BCL_DECLARE_LIMITS_MEMBER(bool, is_signed, false);
	__BCL_DECLARE_LIMITS_MEMBER(int, digits, 1);
	__BCL_DECLARE_LIMITS_MEMBER(int, digits10, 0);
};

__BCL_CONST_DEFIEND(numeric_limits<bool>, bool, is_modulo);
__BCL_CONST_DEFIEND(numeric_limits<bool>, bool, is_signed);
__BCL_CONST_DEFIEND(numeric_limits<bool>, int, digits);
__BCL_CONST_DEFIEND(numeric_limits<bool>, int, digits10);


__BCL_TEMPLATE_NULL class numberic_limits<signed char> :public _Numberic_limits_base
{
public:
	typedef signed char __number;

	static __number min() throw() { return (SCHAR_MIN); }
	static __number max() throw() { return (SCHAR_MAX); }
	static __number epsilon() throw() { return 0; }
	static __number round_error() throw() { return 0; }
	static __number denorm_min() throw() { return 0; }
	static __number infinity() throw() { return 0; }
	static __number quiet_NaN() throw() { return 0; }
	static __number signaling_NaN() throw() { return 0; }

	__BCL_DECLARE_LIMITS_MEMBER(bool, is_signed, CHAR_MIN != 0);
	__BCL_DECLARE_LIMITS_MEMBER(int, digits, CHAR_BIT - (CHAR_MIN != 0 ? 1 : 0));
	__BCL_DECLARE_LIMITS_MEMBER(int, digits10, (CHAR_BIT - (CHAR_MIN != 0 ? 1 : 0))
		* 301L / 1000);
};

__BCL_CONST_DEFIEND(numeric_limits<signed char>, bool, is_signed);
__BCL_CONST_DEFIEND(numeric_limits<signed char>, int, digits);
__BCL_CONST_DEFIEND(numeric_limits<signed char>, int, digits10);


__BCL_TEMPLATE_NULL class numberic_limits<unsigned char> :public _Numberic_limits_base
{
public:
	typedef unsigned char __number;

	static __number min() throw() { return (0); }
	static __number max() throw() { return (UCHAR_MAX); }
	static __number epsilon() throw() { return 0; }
	static __number round_error() throw() { return 0; }
	static __number denorm_min() throw() { return 0; }
	static __number infinity() throw() { return 0; }
	static __number quiet_NaN() throw() { return 0; }
	static __number signaling_NaN() throw() { return 0; }

	__BCL_DECLARE_LIMITS_MEMBER(bool, is_signed, false);
	__BCL_DECLARE_LIMITS_MEMBER(int, digits, CHAR_BIT);
	__BCL_DECLARE_LIMITS_MEMBER(int, digits10, (CHAR_BIT) * 301L / 1000);
};

__BCL_CONST_DEFIEND(numeric_limits<unsigned char>, bool, is_signed);
__BCL_CONST_DEFIEND(numeric_limits<unsigned char>, int, digits);
__BCL_CONST_DEFIEND(numeric_limits<unsigned char>, int, digits10);


__BCL_TEMPLATE_NULL class numberic_limits<short> :public _Numberic_limits_base
{
public:
	typedef short __number;

	static __number min() throw() { return (SHRT_MIN); }
	static __number max() throw() { return (SHRT_MAX); }
	static __number epsilon() throw() { return 0; }
	static __number round_error() throw() { return 0; }
	static __number denorm_min() throw() { return 0; }
	static __number infinity() throw() { return 0; }
	static __number quiet_NaN() throw() { return 0; }
	static __number signaling_NaN() throw() { return 0; }

	__BCL_DECLARE_LIMITS_MEMBER(bool, is_signed, true);
	__BCL_DECLARE_LIMITS_MEMBER(int, digits, CHAR_BIT * sizeof (short) - 1);
	__BCL_DECLARE_LIMITS_MEMBER(int, digits10, (CHAR_BIT * sizeof (short) - 1)
		* 301L / 1000);
};

__BCL_CONST_DEFIEND(numeric_limits<short>, bool, is_signed);
__BCL_CONST_DEFIEND(numeric_limits<short>, int, digits);
__BCL_CONST_DEFIEND(numeric_limits<short>, int, digits10);


__BCL_TEMPLATE_NULL class numberic_limits<unsigned short> :public _Numberic_limits_base
{
public:
	typedef unsigned short __number;

	static __number min() throw() { return (0); }
	static __number max() throw() { return (USHRT_MAX); }
	static __number epsilon() throw() { return 0; }
	static __number round_error() throw() { return 0; }
	static __number denorm_min() throw() { return 0; }
	static __number infinity() throw() { return 0; }
	static __number quiet_NaN() throw() { return 0; }
	static __number signaling_NaN() throw() { return 0; }

	__BCL_DECLARE_LIMITS_MEMBER(bool, is_signed, false);
	__BCL_DECLARE_LIMITS_MEMBER(int, digits, CHAR_BIT * sizeof (unsigned short));
	__BCL_DECLARE_LIMITS_MEMBER(int, digits10, (CHAR_BIT * sizeof (unsigned short))
		* 301L / 1000);
};

__BCL_CONST_DEFIEND(numeric_limits<unsigned short>, bool, is_signed);
__BCL_CONST_DEFIEND(numeric_limits<unsigned short>, int, digits);
__BCL_CONST_DEFIEND(numeric_limits<unsigned short>, int, digits10);



__BCL_TEMPLATE_NULL class numberic_limits<int> :public _Numberic_limits_base
{
public:
	typedef int __number;

	static __number min() throw() { return (INT_MIN); }
	static __number max() throw() { return (INT_MAX); }
	static __number epsilon() throw() { return 0; }
	static __number round_error() throw() { return 0; }
	static __number denorm_min() throw() { return 0; }
	static __number infinity() throw() { return 0; }
	static __number quiet_NaN() throw() { return 0; }
	static __number signaling_NaN() throw() { return 0; }

	__BCL_DECLARE_LIMITS_MEMBER(bool, is_signed, true);
	__BCL_DECLARE_LIMITS_MEMBER(int, digits, CHAR_BIT * sizeof (int) - 1);
	__BCL_DECLARE_LIMITS_MEMBER(int, digits10, (CHAR_BIT * sizeof (int) - 1)
		* 301L / 1000);
};

__BCL_CONST_DEFIEND(numeric_limits<int>, bool, is_signed);
__BCL_CONST_DEFIEND(numeric_limits<int>, int, digits);
__BCL_CONST_DEFIEND(numeric_limits<int>, int, digits10);


__BCL_TEMPLATE_NULL class numberic_limits<unsigned int> :public _Numberic_limits_base
{
public:
	typedef unsigned int __number;

	static __number min() throw() { return (0); }
	static __number max() throw() { return (UINT_MAX); }
	static __number epsilon() throw() { return 0; }
	static __number round_error() throw() { return 0; }
	static __number denorm_min() throw() { return 0; }
	static __number infinity() throw() { return 0; }
	static __number quiet_NaN() throw() { return 0; }
	static __number signaling_NaN() throw() { return 0; }

	__BCL_DECLARE_LIMITS_MEMBER(bool, is_signed, false);
	__BCL_DECLARE_LIMITS_MEMBER(int, digits, CHAR_BIT * sizeof (unsigned int) - 1);
	__BCL_DECLARE_LIMITS_MEMBER(int, digits10, (CHAR_BIT * sizeof (unsigned int) - 1)
		* 301L / 1000);
};

__BCL_CONST_DEFIEND(numeric_limits<unsigned int>, bool, is_signed);
__BCL_CONST_DEFIEND(numeric_limits<unsigned int>, int, digits);
__BCL_CONST_DEFIEND(numeric_limits<unsigned int>, int, digits10);


__BCL_TEMPLATE_NULL class numberic_limits<long> :public _Numberic_limits_base
{
public:
	typedef long __number;

	static __number min() throw() { return (LONG_MIN); }
	static __number max() throw() { return (LONG_MAX); }
	static __number epsilon() throw() { return 0; }
	static __number round_error() throw() { return 0; }
	static __number denorm_min() throw() { return 0; }
	static __number infinity() throw() { return 0; }
	static __number quiet_NaN() throw() { return 0; }
	static __number signaling_NaN() throw() { return 0; }

	__BCL_DECLARE_LIMITS_MEMBER(bool, is_signed, true);
	__BCL_DECLARE_LIMITS_MEMBER(int, digits, CHAR_BIT * sizeof (long) - 1);
	__BCL_DECLARE_LIMITS_MEMBER(int, digits10, (CHAR_BIT * sizeof (long) - 1)
		* 301L / 1000);
};

__BCL_CONST_DEFIEND(numeric_limits<long>, bool, is_signed);
__BCL_CONST_DEFIEND(numeric_limits<long>, int, digits);
__BCL_CONST_DEFIEND(numeric_limits<long>, int, digits10);


__BCL_TEMPLATE_NULL class numberic_limits<unsigned long> :public _Numberic_limits_base
{
public:
	typedef unsigned long __number;

	static __number min() throw() { return (0); }
	static __number max() throw() { return (ULONG_MAX); }
	static __number epsilon() throw() { return 0; }
	static __number round_error() throw() { return 0; }
	static __number denorm_min() throw() { return 0; }
	static __number infinity() throw() { return 0; }
	static __number quiet_NaN() throw() { return 0; }
	static __number signaling_NaN() throw() { return 0; }

	__BCL_DECLARE_LIMITS_MEMBER(bool, is_signed, false);
	__BCL_DECLARE_LIMITS_MEMBER(int, digits, CHAR_BIT * sizeof (unsigned long) - 1);
	__BCL_DECLARE_LIMITS_MEMBER(int, digits10, (CHAR_BIT * sizeof (unsigned long) - 1)
		* 301L / 1000);
};

__BCL_CONST_DEFIEND(numeric_limits<unsigned long>, bool, is_signed);
__BCL_CONST_DEFIEND(numeric_limits<unsigned long>, int, digits);
__BCL_CONST_DEFIEND(numeric_limits<unsigned long>, int, digits10);

__BCL_TEMPLATE_NULL class numberic_limits<_LONGLONG> :public _Numberic_limits_base
{
public:
	typedef _LONGLONG __number;

	static __number min() throw() { return (-_LLONG_MAX - _C2); }
	static __number max() throw() { return (_LLONG_MAX); }
	static __number epsilon() throw() { return 0; }
	static __number round_error() throw() { return 0; }
	static __number denorm_min() throw() { return 0; }
	static __number infinity() throw() { return 0; }
	static __number quiet_NaN() throw() { return 0; }
	static __number signaling_NaN() throw() { return 0; }

	__BCL_DECLARE_LIMITS_MEMBER(bool, is_signed, true);
	__BCL_DECLARE_LIMITS_MEMBER(int, digits, CHAR_BIT * sizeof (_LONGLONG) - 1);
	__BCL_DECLARE_LIMITS_MEMBER(int, digits10, (CHAR_BIT * sizeof (_LONGLONG) - 1)
		* 301L / 1000);
};

__BCL_CONST_DEFIEND(numeric_limits<_LONGLONG>, bool, is_signed);
__BCL_CONST_DEFIEND(numeric_limits<_LONGLONG>, int, digits);
__BCL_CONST_DEFIEND(numeric_limits<_LONGLONG>, int, digits10);


__BCL_TEMPLATE_NULL class numberic_limits<_ULONGLONG> :public _Numberic_limits_base
{
public:
	typedef _ULONGLONG __number;

	static __number min() throw() { return (0); }
	static __number max() throw() { return (_ULLONG_MAX); }
	static __number epsilon() throw() { return 0; }
	static __number round_error() throw() { return 0; }
	static __number denorm_min() throw() { return 0; }
	static __number infinity() throw() { return 0; }
	static __number quiet_NaN() throw() { return 0; }
	static __number signaling_NaN() throw() { return 0; }

	__BCL_DECLARE_LIMITS_MEMBER(bool, is_signed, false);
	__BCL_DECLARE_LIMITS_MEMBER(int, digits, CHAR_BIT * sizeof (_ULONGLONG));
	__BCL_DECLARE_LIMITS_MEMBER(int, digits10, (CHAR_BIT * sizeof (_ULONGLONG))
		* 301L / 1000);
};

__BCL_CONST_DEFIEND(numeric_limits<_ULONGLONG>, bool, is_signed);
__BCL_CONST_DEFIEND(numeric_limits<_ULONGLONG>, int, digits);
__BCL_CONST_DEFIEND(numeric_limits<_ULONGLONG>, int, digits10);


__BCL_TEMPLATE_NULL class numberic_limits<float> :public _Numberic_limits_base
{
public:
	typedef float __number;

	static __number min() throw() { return (FLT_MIN); }
	static __number max() throw() { return (FLT_MAX); }
	static __number epsilon() throw() { return FLT_EPSILON; }
	static __number round_error() throw() { return 0.5; }
	static __number denorm_min() throw() { return (::_FDenorm._Float); }
	static __number infinity() throw() { return (::_FInf._Float); }
	static __number quiet_NaN() throw() { return (::_FNan._Float); }
	static __number signaling_NaN() throw() { return (::_FSnan._Float); }

	__BCL_DECLARE_LIMITS_MEMBER(int, digits, FLT_MANT_DIG);
	__BCL_DECLARE_LIMITS_MEMBER(int, digits10, FLT_DIG);
	__BCL_DECLARE_LIMITS_MEMBER(int, max_exponent, (int)FLT_MAX_EXP);
	__BCL_DECLARE_LIMITS_MEMBER(int, max_exponent10, (int)FLT_MAX_10_EXP);
	__BCL_DECLARE_LIMITS_MEMBER(int, min_exponent, (int)FLT_MIN_EXP);
	__BCL_DECLARE_LIMITS_MEMBER(int, min_exponent10, (int)FLT_MIN_10_EXP);
};

__BCL_CONST_DEFIEND(numeric_limits<float>, int, digits);
__BCL_CONST_DEFIEND(numeric_limits<float>, int, digits10);
__BCL_CONST_DEFIEND(numeric_limits<float>, int, max_exponent);
__BCL_CONST_DEFIEND(numeric_limits<float>, int, max_exponent10);
__BCL_CONST_DEFIEND(numeric_limits<float>, int, min_exponent);
__BCL_CONST_DEFIEND(numeric_limits<float>, int, min_exponent10);


__BCL_TEMPLATE_NULL class numberic_limits<double> :public _Numberic_limits_base
{
public:
	typedef double __number;

	static __number min() throw() { return (DBL_MIN); }
	static __number max() throw() { return (DBL_MAX); }
	static __number epsilon() throw() { return DBL_EPSILON; }
	static __number round_error() throw() { return 0.5; }
	static __number denorm_min() throw() { return (::_Denorm._Double); }
	static __number infinity() throw() { return (::_Inf._Double); }
	static __number quiet_NaN() throw() { return (::_Nan._Double); }
	static __number signaling_NaN() throw() { return (::_Snan._Double); }

	__BCL_DECLARE_LIMITS_MEMBER(int, digits, DBL_MANT_DIG);
	__BCL_DECLARE_LIMITS_MEMBER(int, digits10, DBL_DIG);
	__BCL_DECLARE_LIMITS_MEMBER(int, max_exponent, (int)DBL_MAX_EXP);
	__BCL_DECLARE_LIMITS_MEMBER(int, max_exponent10, (int)DBL_MAX_10_EXP);
	__BCL_DECLARE_LIMITS_MEMBER(int, min_exponent, (int)DBL_MIN_EXP);
	__BCL_DECLARE_LIMITS_MEMBER(int, min_exponent10, (int)DBL_MIN_10_EXP);
};

__BCL_CONST_DEFIEND(numeric_limits<double>, int, digits);
__BCL_CONST_DEFIEND(numeric_limits<double>, int, digits10);
__BCL_CONST_DEFIEND(numeric_limits<double>, int, max_exponent);
__BCL_CONST_DEFIEND(numeric_limits<double>, int, max_exponent10);
__BCL_CONST_DEFIEND(numeric_limits<double>, int, min_exponent);
__BCL_CONST_DEFIEND(numeric_limits<double>, int, min_exponent10);


__BCL_TEMPLATE_NULL class numberic_limits<long double> :public _Numberic_limits_base
{
public:
	typedef long double __number;

	static __number min() throw() { return (LDBL_MIN); }
	static __number max() throw() { return (LDBL_MAX); }
	static __number epsilon() throw() { return LDBL_EPSILON; }
	static __number round_error() throw() { return 0.5; }
	static __number denorm_min() throw() { return (::_LDenorm._Long_double); }
	static __number infinity() throw() { return (::_LInf._Long_double); }
	static __number quiet_NaN() throw() { return (::_LNan._Long_double); }
	static __number signaling_NaN() throw() { return (::_LSnan._Long_double); }

	__BCL_DECLARE_LIMITS_MEMBER(int, digits, LDBL_MANT_DIG);
	__BCL_DECLARE_LIMITS_MEMBER(int, digits10, LDBL_DIG);
	__BCL_DECLARE_LIMITS_MEMBER(int, max_exponent, (int)LDBL_MAX_EXP);
	__BCL_DECLARE_LIMITS_MEMBER(int, max_exponent10, (int)LDBL_MAX_10_EXP);
	__BCL_DECLARE_LIMITS_MEMBER(int, min_exponent, (int)LDBL_MIN_EXP);
	__BCL_DECLARE_LIMITS_MEMBER(int, min_exponent10, (int)LDBL_MIN_10_EXP);
};

__BCL_CONST_DEFIEND(numeric_limits<long double>, int, digits);
__BCL_CONST_DEFIEND(numeric_limits<long double>, int, digits10);
__BCL_CONST_DEFIEND(numeric_limits<long double>, int, max_exponent);
__BCL_CONST_DEFIEND(numeric_limits<long double>, int, max_exponent10);
__BCL_CONST_DEFIEND(numeric_limits<long double>, int, min_exponent);
__BCL_CONST_DEFIEND(numeric_limits<long double>, int, min_exponent10);

__BCL_END_NAMESPACE

#endif  __STORMWIDGET_STORMWIDGET_BASECLASSLIBRARY_NUMBERIC_LIMITS_H